package com.heu.blood.storge.service.impl;

import com.alibaba.excel.EasyExcel;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.heu.blood.common.commponent.DictionaryLoader;
import com.heu.blood.common.enums.BloodStateEnum;
import com.heu.blood.common.utils.ExcelUtil;
import com.heu.blood.common.utils.PageUtils;
import com.heu.blood.common.utils.Query;
import com.heu.blood.globalExceptionHandler.MyException;
import com.heu.blood.match.dao.BloodInformationDao;
import com.heu.blood.match.entity.BloodInformationEntity;
import com.heu.blood.match.service.BloodInformationService;
import com.heu.blood.security.entity.LoginUser;
import com.heu.blood.storge.dao.BloodVerifyStorgeDao;
import com.heu.blood.storge.dictenum.BloodVerifyEnum;
import com.heu.blood.storge.entity.BloodBackEntity;
import com.heu.blood.storge.entity.BloodInStorgeEntity;
import com.heu.blood.storge.entity.BloodVerifyStorgeEntity;
import com.heu.blood.storge.exception.BloodVerifyStorgeException;
import com.heu.blood.storge.exception.InstorageException;
import com.heu.blood.storge.listener.ImportDataForVerifyListener;
import com.heu.blood.storge.service.BloodBackService;
import com.heu.blood.storge.service.BloodInStorgeService;
import com.heu.blood.storge.service.BloodVerifyStorgeService;
import com.heu.blood.storge.vo.BloodContactVerifyAndInStorgeVo;
import com.heu.blood.storge.vo.BloodInformationForExcelVo;
import lombok.extern.slf4j.Slf4j;
import org.apache.logging.log4j.util.Strings;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import static com.heu.blood.common.enums.BloodStorgeEnum.*;
import static com.heu.blood.common.enums.CommonEnum.IF_SHOW;
import static com.heu.blood.common.enums.CommonEnum.IS_NOT_DELETED;


@Service("bloodVerifyStorgeService")
@Slf4j
public class BloodVerifyStorgeServiceImpl extends ServiceImpl<BloodVerifyStorgeDao, BloodVerifyStorgeEntity> implements BloodVerifyStorgeService {
    @Autowired
    private BloodVerifyStorgeDao bloodVerifyStorgedao;
    @Autowired
    private BloodInformationDao bloodInformationDao;
    @Autowired
    private DictionaryLoader dictionaryLoader;
    @Autowired
    private ImportDataForVerifyListener importDataForVerifyListener;
    @Autowired
    private BloodInformationService bloodInformationService;
    @Autowired
    private BloodInStorgeService bloodInStorgeService;
    @Autowired
    private BloodBackService bloodBackService;

    @Override
    public PageUtils queryPage(Map<String, Object> params) {
        //构造一个血液验证对象接收
        BloodVerifyStorgeEntity bloodVerifyStorgeEntity = new BloodVerifyStorgeEntity();
        if (Strings.isNotBlank((String) params.get("bloodId"))){
            bloodVerifyStorgeEntity.setBloodId((String) params.get("bloodId"));//设置血液ID
        }
        if (Strings.isNotBlank((String) params.get("aboBloodType"))){
            bloodVerifyStorgeEntity.setAboBloodType((String) params.get("aboBloodType"));//设置ABO血型
        }
        if (Strings.isNotBlank((String) params.get("rhBloodType"))){
            bloodVerifyStorgeEntity.setRhBloodType((String) params.get("rhBloodType"));//设置RH血型
        }
        if (Strings.isNotBlank((String) params.get("verifyResult"))){
            bloodVerifyStorgeEntity.setVerifyResult((String) params.get("verifyResult"));//设置核验
        }
        if (Strings.isNotBlank((String) params.get("rhSplitType"))){
            bloodVerifyStorgeEntity.setRhSplitType((String) params.get("rhSplitType")); //设置RH分型.
        }
        if (Strings.isNotBlank((String) params.get("bloodType"))){
            bloodVerifyStorgeEntity.setBloodType((String) params.get("bloodType"));//设置bloodtype
        }
        if (Strings.isNotBlank((String) params.get("verifyPersonId"))){
            bloodVerifyStorgeEntity.setVerifyPersonId((String) params.get("verifyPersonId"));//设置血液验证人ID
        }
        if (Strings.isNotBlank((String) params.get("verifyPerson"))){
            bloodVerifyStorgeEntity.setVerifyPerson((String) params.get("verifyPerson"));//设置血液验证人
        }
        LambdaQueryWrapper<BloodVerifyStorgeEntity> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(Strings.isNotBlank(bloodVerifyStorgeEntity.getBloodId()),BloodVerifyStorgeEntity::getBloodId,bloodVerifyStorgeEntity.getBloodId())
                    .eq(Strings.isNotBlank(bloodVerifyStorgeEntity.getAboBloodType()),BloodVerifyStorgeEntity::getAboBloodType,bloodVerifyStorgeEntity.getAboBloodType())
                    .eq(Strings.isNotBlank(bloodVerifyStorgeEntity.getRhBloodType()),BloodVerifyStorgeEntity::getRhBloodType,bloodVerifyStorgeEntity.getRhBloodType())
                    .eq(Strings.isNotBlank(bloodVerifyStorgeEntity.getRhSplitType()),BloodVerifyStorgeEntity::getRhSplitType,bloodVerifyStorgeEntity.getRhSplitType())
                    .eq(Strings.isNotBlank(bloodVerifyStorgeEntity.getBloodType()),BloodVerifyStorgeEntity::getBloodType,bloodVerifyStorgeEntity.getBloodType())
                    .eq(BloodVerifyStorgeEntity::getIfShow,IF_SHOW.code())
                    .eq(BloodVerifyStorgeEntity::getIsDeleted,IS_NOT_DELETED.code())
                    .eq(Strings.isNotBlank(bloodVerifyStorgeEntity.getVerifyPersonId()),BloodVerifyStorgeEntity::getVerifyPersonId,bloodVerifyStorgeEntity.getVerifyPersonId())
                    .eq(Strings.isNotBlank(bloodVerifyStorgeEntity.getVerifyPerson()),BloodVerifyStorgeEntity::getVerifyPerson,bloodVerifyStorgeEntity.getVerifyPerson())
                    .eq(Strings.isNotBlank(bloodVerifyStorgeEntity.getVerifyResult()),BloodVerifyStorgeEntity::getVerifyResult,bloodVerifyStorgeEntity.getVerifyResult());
        String startTime = "";
        String endTime = "";
        if (Strings.isNotBlank((String) params.get("verifyTimeStart"))){
            startTime = (String) params.get("verifyTimeStart"); //设置开始时间
        }
        if (Strings.isNotBlank((String) params.get("verifyTimeStart"))){
            endTime = (String) params.get("verifyTimeEnd"); //设置开始时间
        }
        if(Strings.isNotBlank(startTime)){
            queryWrapper.ge(startTime != null, BloodVerifyStorgeEntity::getGmtCreate, startTime);
        }
        if(Strings.isNotBlank(endTime)){
            queryWrapper.le(endTime != null, BloodVerifyStorgeEntity::getGmtCreate, endTime);
        }
        queryWrapper.orderByDesc(BloodVerifyStorgeEntity::getGmtCreate);
        //加入了按照时间倒排
        IPage<BloodVerifyStorgeEntity> page = this.page(
                new Query<BloodVerifyStorgeEntity>().getPage(params),
                queryWrapper
        );

        return new PageUtils(page);
    }
    @Override
    public BloodVerifyStorgeEntity bloodCheck(BloodInformationEntity bloodInformationEntity) {
        //校验接收的对象是否为空
        if (bloodInformationEntity == null) {
            return null;
        }
        //如果血液ID不为空
        if (Strings.isNotBlank((String) bloodInformationEntity.getBloodId())) {
            // 构造条件构造器对象
            LambdaQueryWrapper<BloodVerifyStorgeEntity> queryWrapper = new LambdaQueryWrapper<>();
            //添加过滤条件 根据bloodId相等
            queryWrapper.eq(Strings.isNotBlank(bloodInformationEntity.getBloodId()), BloodVerifyStorgeEntity::getBloodId, bloodInformationEntity.getBloodId());
            //找到相等id的验证对象
            BloodVerifyStorgeEntity bloodVerifyStorgeEntityBySelect = bloodVerifyStorgedao.selectOne(queryWrapper);
            //检验是否为空
            if(bloodVerifyStorgeEntityBySelect == null) return null;
            log.info(String.valueOf(bloodVerifyStorgeEntityBySelect));
            //接收前端bloodinformation参数
            String BloodInformationEntityAbo = bloodInformationEntity.getAboBloodType();
            String BloodInformationEntityRh = bloodInformationEntity.getRhBloodType();
            String BloodInformationEntityRhSplit = "abc";//表中没有先预留
            //接收验证表信息参数
            String BloodVerifyStorgeAbo = bloodVerifyStorgeEntityBySelect.getAboBloodType();
            String BloodVerifyStorgeRh = bloodVerifyStorgeEntityBySelect.getRhBloodType();
            String BloodVerifyStorgeRhSlt = "abc";//默认一个abc先
            //flag存放是否更新成功
            int flag =0;
            //检验ABO
            if (BloodInformationEntityAbo.equals(BloodVerifyStorgeAbo)) {
                //检验RH
                if (BloodInformationEntityRh.equals(BloodVerifyStorgeRh)) {
                    //检验RH分型
                    if (BloodInformationEntityRhSplit.equals(BloodVerifyStorgeRhSlt)) {
                        //通过 则更新verify_result字段
                        bloodVerifyStorgeEntityBySelect.setVerifyResult(BLOOD_VERIFY_SUCCESS.code());
                        //数据库更新
                        flag = bloodVerifyStorgedao.updateById(bloodVerifyStorgeEntityBySelect);
                        log.info(String.valueOf(flag));
                    }else{
                        //RH分型检验未通过
                        bloodVerifyStorgeEntityBySelect.setVerifyResult(BLOOD_VERIFY_RH_SPLIT_FAIL.code());
                        //数据库更新
                        flag = bloodVerifyStorgedao.updateById(bloodVerifyStorgeEntityBySelect);
                    }
                }else {
                    //RH检验未通过
                    bloodVerifyStorgeEntityBySelect.setVerifyResult(BLOOD_VERIFY_RH_FAIL.code());
                    //数据库更新
                    flag = bloodVerifyStorgedao.updateById(bloodVerifyStorgeEntityBySelect);
                }
            }else{
                //abo检验未通过
                bloodVerifyStorgeEntityBySelect.setVerifyResult(BLOOD_VERIFY_ABO_FAIL.code());
                //数据库更新
                flag = bloodVerifyStorgedao.updateById(bloodVerifyStorgeEntityBySelect);
            }

            if(flag==1){
                //证明更新完成
                //返回对象
                return bloodVerifyStorgeEntityBySelect;
            }
        }
        return null;
    }

    @Override
    public List<Map> getListByExcel(InputStream is, String fileName) {
        try{
            //解析Excel中的数据
            List<Map> BloodInformationList = new ExcelUtil(new BloodInformationForExcelVo()).AnalysisExcel(is, fileName);
            //每个Map对应一个Entity实体的map解析
//            for(Map map : BloodInformationList){
//                //对于每个map应该提供一个封装成实体类的接口
//            }
            return BloodInformationList;
        }catch (Exception e){
            e.printStackTrace();
        }
        return new ArrayList<>();
    }

    @Override
    public BloodVerifyStorgeEntity convertToVerifyStorge(Map bloodInformationMap) {
        Map<String,String> subDict = dictionaryLoader.getSubDict();
        BloodVerifyStorgeEntity bloodVerifyStorgeEntity = new BloodVerifyStorgeEntity();
        if(bloodInformationMap.size() != 0){
            if(bloodInformationMap.get("bloodId") != null){
                bloodVerifyStorgeEntity.setBloodId((String) bloodInformationMap.get("bloodId"));
            }
            if(bloodInformationMap.get("aboBloodType") != null){
                String newAboBloodType = subDict.get((String) bloodInformationMap.get("aboBloodType"));
                bloodVerifyStorgeEntity.setAboBloodType(newAboBloodType);
            }
            if(bloodInformationMap.get("rhBloodType") != null){
                String newRhBloodType = subDict.get((String)bloodInformationMap.get("rhBloodType"));
                bloodVerifyStorgeEntity.setRhBloodType(newRhBloodType);
            }
            bloodVerifyStorgeEntity.setRhSplitType("ab");
        }
        return bloodVerifyStorgeEntity;
    }

    @Override
    public Boolean BatchImportBloodVerifyStorge(List<Map> bloodInformationList) {
        //存储库存检验信息列表
        List<BloodVerifyStorgeEntity> bloodVerifyStorgeEntityList = new ArrayList<>();
        for (Map map : bloodInformationList) {
            //装载列表
            bloodVerifyStorgeEntityList.add(convertToVerifyStorge(map));
        }
        //记录结果
        boolean res = this.saveBatch(bloodVerifyStorgeEntityList);
        return res;
    }

    @Override
    public List<BloodVerifyStorgeEntity> convertFromBloodinformationlistToBloodVerifyStorge(List<BloodInformationEntity> bloodInformationEntityList) {
        //将血液信息列表转变为血液检验列表
        List<BloodVerifyStorgeEntity> bloodVerifyStorgeEntityList = new ArrayList<>();
        for (BloodInformationEntity bloodInformationEntity : bloodInformationEntityList) {
            BloodVerifyStorgeEntity bloodVerifyStorgeEntity = new BloodVerifyStorgeEntity();
            bloodVerifyStorgeEntity.setBloodId(bloodInformationEntity.getBloodId());
            bloodVerifyStorgeEntity.setBloodCount(bloodInformationEntity.getBloodCount());
            bloodVerifyStorgeEntity.setMeasurementUnit(bloodInformationEntity.getMeasurementUnit());
            bloodVerifyStorgeEntity.setBloodType(bloodInformationEntity.getBloodType());
            bloodVerifyStorgeEntity.setAboBloodType(bloodInformationEntity.getAboBloodType());
            bloodVerifyStorgeEntity.setRhBloodType(bloodInformationEntity.getRhBloodType());
            bloodVerifyStorgeEntity.setRhSplitType("ab");
            bloodVerifyStorgeEntityList.add(bloodVerifyStorgeEntity);
            Authentication authentication= SecurityContextHolder.getContext().getAuthentication();
            if(authentication != null && authentication.isAuthenticated()) {
                LoginUser loginUser = (LoginUser) authentication.getPrincipal();
                //写入当前用户信息
                bloodVerifyStorgeEntity.setVerifyPerson(loginUser.getUser().getUserName());
                bloodVerifyStorgeEntity.setVerifyPersonId(loginUser.getUser().getUserId());
            }
        }
        return bloodVerifyStorgeEntityList;
    }

    @Override
    public void importExcelToBloodVerify(MultipartFile multipartFile) {
        InputStream inputStream = null;
        try {
            inputStream = multipartFile.getInputStream();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        // 这里 需要指定读用哪个class去读，然后读取第一个sheet 文件流会自动关闭
        EasyExcel.read(inputStream, BloodInformationEntity.class,importDataForVerifyListener).sheet().doRead();
    }

    @Override
    public List<BloodVerifyStorgeEntity> listForBloodVerifyStorage() {
        LambdaQueryWrapper<BloodVerifyStorgeEntity> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(BloodVerifyStorgeEntity::getVerifyResult,NOT_BLOOD_VERIFIED_COMPARISON.code());
        //找到检验表中所有未对比的数据
        List<BloodVerifyStorgeEntity> bloodVerifyStorgeEntityList = bloodVerifyStorgedao.selectList(queryWrapper);
        return bloodVerifyStorgeEntityList;
    }

    @Override
    public void bloodBatchCheck(List<BloodVerifyStorgeEntity> bloodVerifyStorgeEntityList) {
        if (bloodVerifyStorgeEntityList.size() == 0){
            //数据库中没有检验数据
            return;
        }
        for (BloodVerifyStorgeEntity bloodVerifyStorgeEntity : bloodVerifyStorgeEntityList) {
            bloodSimpleCheck(bloodVerifyStorgeEntity);
        }

    }
    @Transactional
    @Override
    public void bloodSimpleCheck(BloodVerifyStorgeEntity bloodVerifyStorgeEntity) {
        //如果血液
       if (bloodVerifyStorgeEntity == null && bloodVerifyStorgeEntity.getBloodId() == null){
           //不存在血液
           return;
       }
        //对于其中的每一条血液检验数据 先与血液信息表连接 找到那条血液信息
        LambdaQueryWrapper<BloodInformationEntity> queryWrapper = new LambdaQueryWrapper<>();
        //添加过滤条件 根据bloodId相等
        queryWrapper.eq(BloodInformationEntity::getBloodId, bloodVerifyStorgeEntity.getBloodId());
        //找到对应的血液信息表里面的数据
        BloodInformationEntity bloodInformationEntity = bloodInformationDao.selectOne(queryWrapper);
        if (bloodInformationEntity == null){
            //血液信息表不存在这个血液
            return;
        }
        // TODO: 2023/11/26
        if (bloodInformationEntity.getAboBloodType().equals(bloodVerifyStorgeEntity.getAboBloodType())){
            //abo核验成功
            if (bloodInformationEntity.getRhBloodType().equals(bloodVerifyStorgeEntity.getRhBloodType())){
                //Rh核验成功
                if (bloodVerifyStorgeEntity.getRhSplitType().equals("ab")){
                    //rh分型核验成功
                    if (bloodInformationEntity.getBloodType().equals(bloodVerifyStorgeEntity.getBloodType())){
                        //血液类型核验成功
                        if(bloodInformationEntity.getBloodCount().equals(bloodVerifyStorgeEntity.getBloodCount())){
                            //血液数量检验成功
                            if(bloodInformationEntity.getMeasurementUnit().equals(bloodVerifyStorgeEntity.getMeasurementUnit())){
                                //血液计量单位核验成功
                                //到这都成功了 更新检验表状态
                                bloodVerifyStorgeEntity.setVerifyResult(BLOOD_VERIFY_SUCCESS.code());
                                bloodVerifyStorgedao.updateById(bloodVerifyStorgeEntity);
                                //更新入库表状态为在库
                                bloodInStorgeService.updateInStorgeBloodStatebyBloodId(bloodInformationEntity.getBloodId(),BLOOD_IN_STOCK_STATE.code());
                                //更新血液信息表状态为在库
                                bloodInformationService.updateBloodStateByBloodId(bloodInformationEntity.getBloodId(),BLOOD_IN_STOCK_STATE.code());
                                //更新血液信息表的测试标志为1
                                bloodInformationService.updateTestFlagByBloodId(bloodInformationEntity.getBloodId());
                            }else {
                                //血液计量单位核验失败
                                bloodAbstractFourMethodforUnsuccessful(bloodInformationEntity, BLOOD_VERITY_BLOOD_MEASUREMENTUNIT_FAIL.code());
                            }
                        }else {
                            //血液数量核验失败
                            bloodAbstractFourMethodforUnsuccessful(bloodInformationEntity,BLOOD_VERITY_BLOOD_COUNT_FAIL.code());
                        }
                    }else {
                        //血液类型核验失败
                        bloodAbstractFourMethodforUnsuccessful(bloodInformationEntity, BLOOD_VERITY_BLOOD_TYPE_FAIL.code());
                    }
                }else {
                    //rh分型核验失败
                    bloodAbstractFourMethodforUnsuccessful(bloodInformationEntity,BLOOD_VERIFY_RH_SPLIT_FAIL.code());
                }
            }else {
                //abo成功 rh失败
                bloodAbstractFourMethodforUnsuccessful(bloodInformationEntity,BLOOD_VERIFY_RH_FAIL.code());
            }
        }else {
            //abo核验失败 则删除对应血液信息表中的数据 并将血液入库表中的
            bloodAbstractFourMethodforUnsuccessful(bloodInformationEntity,BLOOD_VERIFY_ABO_FAIL.code());
        }

    }
    @Transactional
    @Override
    public void bloodAbstractFourMethodforUnsuccessful(BloodInformationEntity bloodInformationEntity, String verifyResult) {
        //退血表数据增加
        //先将血液信息表转变为血液退血表中的字段
        BloodBackEntity bloodBackEntity = bloodBackService.convertBloodInformationToBloodBackEntity(bloodInformationEntity);
        bloodBackService.save(bloodBackEntity);
        //更新血液信息表的测试标志为1
        bloodInformationService.updateTestFlagByBloodId(bloodInformationEntity.getBloodId());
        //在血液信息表中删除该数据
        int i = bloodInformationDao.deleteById(bloodInformationEntity);
        //血液入库表状态更新
        boolean return_to_blood_station = bloodInStorgeService.updateInStorgeBloodStatebyBloodId(bloodInformationEntity.getBloodId(), BLOOD_RETURN_TO_STATION.code());
        //血液检验表中结果填充
        LambdaUpdateWrapper<BloodVerifyStorgeEntity> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(BloodVerifyStorgeEntity::getBloodId,bloodInformationEntity.getBloodId());
        updateWrapper.set(BloodVerifyStorgeEntity::getVerifyResult,verifyResult);
        int update = bloodVerifyStorgedao.update(null, updateWrapper);

    }

    @Override
    public void UpdateVerifyResultByBloodIdAndVerifyUnsuccessReason(String bloodId, String verifyUnsuccessReason) {
        LambdaUpdateWrapper<BloodVerifyStorgeEntity> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(Strings.isNotBlank(bloodId),BloodVerifyStorgeEntity::getBloodId,bloodId)
                     .set(BloodVerifyStorgeEntity::getVerifyResult,verifyUnsuccessReason);
        this.update(updateWrapper);

    }

    @Override
    public PageUtils bloodContactVerifyAndInStorgeByBloodId(Map<String, Object> params) {
        String bloodId="";
        if (Strings.isNotBlank((String) params.get("bloodId"))){

            bloodId = (String) params.get("bloodId");
            log.info(bloodId);
        }
        QueryWrapper<BloodContactVerifyAndInStorgeVo> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq(Strings.isNotBlank(bloodId),"bvs.blood_id",bloodId)
                    .eq("bvs.verify_result",BLOOD_VERIFY_WAIT.code())
                    .orderByDesc("bvs.gmt_create");
        IPage<BloodContactVerifyAndInStorgeVo> page1 = bloodVerifyStorgedao.contactVerifyandInStorgeByBloodId(new Query<BloodContactVerifyAndInStorgeVo>().getPage(params),queryWrapper);
        log.info(page1.toString());
        return new PageUtils(page1);
    }

    @Override
    public void batchUpdateVerifyResultForVerifyStorgeByBloodId(String[] bloodids) {
        LambdaUpdateWrapper<BloodVerifyStorgeEntity> queryWrapper = new LambdaUpdateWrapper<>();
        queryWrapper.in(BloodVerifyStorgeEntity::getBloodId,bloodids)
                .eq(BloodVerifyStorgeEntity::getIfShow,IF_SHOW.code())
                .eq(BloodVerifyStorgeEntity::getIsDeleted,IS_NOT_DELETED.code())
                .set(BloodVerifyStorgeEntity::getVerifyResult,BLOOD_VERIFY_SUCCESS.code());
        this.update(queryWrapper);
    }

    @Override
    public int batchSave(List<BloodVerifyStorgeEntity> bloodVerifyStorgeEntityList) {
        // 为每一个实体设置状态为待确认
        Map<String, String> bloodTypeDictTranslate = dictionaryLoader.getBloodTypeDictTranslate();
        Map<String, String> measurementUnitDictTranslate = dictionaryLoader.getMeasurementUnitDictTranslate();
        for (BloodVerifyStorgeEntity bloodVerifyStorgeEntity : bloodVerifyStorgeEntityList) {
            bloodVerifyStorgeEntity.setVerifyResult(BloodVerifyEnum.VERIFY_WAIT.code());
            String bloodTypeCode = bloodTypeDictTranslate.get(bloodVerifyStorgeEntity.getBloodType());
            String measurementUnitCode = measurementUnitDictTranslate.get(bloodVerifyStorgeEntity.getMeasurementUnit());
            bloodVerifyStorgeEntity.setBloodType(bloodTypeCode);
            bloodVerifyStorgeEntity.setMeasurementUnit(measurementUnitCode);
        }
        this.saveBatch(bloodVerifyStorgeEntityList);
        return 0;
    }

    @Override
    public BloodContactVerifyAndInStorgeVo getVerifyCompareRes(BloodVerifyStorgeEntity bloodVerifyStorgeEntity) {
        // 先根据血液id查出来一条数据，该数据为库存里面存放的
        LambdaQueryWrapper<BloodInStorgeEntity> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(BloodInStorgeEntity::getBloodId,bloodVerifyStorgeEntity.getBloodId());
        BloodInStorgeEntity inStorageRes = bloodInStorgeService.getOne(queryWrapper);
        // 创建结果数据
        BloodContactVerifyAndInStorgeVo res = new BloodContactVerifyAndInStorgeVo();
        // 之后把库存存放的拷贝进去
        BeanUtils.copyProperties(inStorageRes,res);
        // 把检验的设置进去
        res.setVerABOBloodType(bloodVerifyStorgeEntity.getAboBloodType());
        res.setVerBloodCount(bloodVerifyStorgeEntity.getBloodCount());
        res.setVerBloodId(bloodVerifyStorgeEntity.getBloodId());
        res.setVerRhBloodType(bloodVerifyStorgeEntity.getRhBloodType());
        res.setVerMeasurementUnit(bloodVerifyStorgeEntity.getMeasurementUnit());
        res.setVerBloodType(bloodVerifyStorgeEntity.getBloodType());
        res.setAntibodyScreening(bloodVerifyStorgeEntity.getAntibodyScreening());
        return res;
    }

    @Override
    public int saveWithCheck(BloodVerifyStorgeEntity bloodVerifyStorge) {
        LambdaQueryWrapper<BloodVerifyStorgeEntity> verifyWrapper = new LambdaQueryWrapper<>();
        verifyWrapper.eq(BloodVerifyStorgeEntity::getBloodId,bloodVerifyStorge.getBloodId());
        BloodVerifyStorgeEntity bloodVerifyStorgeOne = this.getOne(verifyWrapper);
        // 只要是血液检验表里面有重复的就不能在搞了
        if(bloodVerifyStorgeOne != null){
            throw new MyException(BloodVerifyStorgeException.DUPLICATE_BLOODID);
        }
        // 查询一下库存的信息
        LambdaQueryWrapper<BloodInStorgeEntity> storageWrapper = new LambdaQueryWrapper<>();
        storageWrapper.eq(BloodInStorgeEntity::getBloodId,bloodVerifyStorge.getBloodId());
        BloodInStorgeEntity inStorageOne = bloodInStorgeService.getOne(storageWrapper);
        // 没有该血液id报错抛异常
        if(inStorageOne == null){
            throw new MyException(InstorageException.NO_BLOODID_STORAGE);
        }
        // 血液状态不是入库待检状态
        if(!inStorageOne.getBloodState().equals(BloodStateEnum.IN_STORAGE_TEST.code())){
            throw new MyException(InstorageException.STATE_WRONG_IN_STORAGE_TEST);
        }
        // 将检验结果状态设置为待确认
        bloodVerifyStorge.setVerifyResult(BloodVerifyEnum.VERIFY_WAIT.code());
        this.save(bloodVerifyStorge);
        return 0;
    }

    @Override
    public BloodInStorgeEntity checkInStorageTestStatus(String bloodId) {
        // 查询blood_in_storge表
        LambdaQueryWrapper<BloodInStorgeEntity> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(BloodInStorgeEntity::getBloodId, bloodId)
                .eq(BloodInStorgeEntity::getBloodState, BloodStateEnum.IN_STORAGE_TEST.code());
        BloodInStorgeEntity entity = bloodInStorgeService.getOne(queryWrapper);
        return entity;
    }


}


